COMMENT ⊗   VALID 00005 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	∂17-Feb-90  1834	JMC 	some very preliminary comments on your ideas on lifting
C00004 00003	∂16-Feb-90  1549	guha@sumex-aim.stanford.edu 	some very preliminary ideas on emotions and lifting
C00032 00004	Thanks for your comments. 
C00033 00005
C00050 ENDMK
C⊗;
∂17-Feb-90  1834	JMC 	some very preliminary comments on your ideas on lifting
To:   guha@SUMEX-AIM.STANFORD.EDU
[In reply to message sent Fri, 16 Feb 1990 15:52:32 PST.]

	This seems to be on the right general track to me.  I agree
that the examples are good to give us guidance.

Your (1) seems to have c1 and c2 interchanged.

If it's ok with you, I'll show this to Vladimir Lifschitz,
because he is now thinking general thoughts about the
formalization of common sense, and he is very good at figuring
out what axioms mean including finding unintended models of them.

Your use of  mainEvent(x,c)  can be replaced by a relation between
c1 and c2 of the form

c2 = focus(c1,FredsGraduation)

or else

focusses(c2,FredsGarduation,c1),

which is how I had been relating contexts.  It doesn't seem
that one scheme is clearly better than the other, and we can have
both.

I'm doubtful about context types, and anyway the paragraph beginning
"Actually axioms..." isn't clear to me.  I'd like to get by with
just contexts.

∂16-Feb-90  1549	guha@sumex-aim.stanford.edu 	some very preliminary ideas on emotions and lifting
Received: from sumex-aim.stanford.edu by SAIL.Stanford.EDU with TCP; 16 Feb 90  15:49:49 PST
Received: by sumex-aim.stanford.edu (4.0/inc-1.0)
	id AA06952; Fri, 16 Feb 90 15:52:33 PST
Date: Fri, 16 Feb 1990 15:52:32 PST
From: "Ramanathan V. Guha" <guha@sumex-aim.stanford.edu>
To: jmc@sail.stanford.edu
Subject: some very preliminary ideas on emotions and lifting
Message-Id: <CMM.0.88.635212352.guha@sumex-aim.stanford.edu>

A treatment of emotions from the perspective of contexts/microtheories.

The emotions  that seem amenable to this approach are happy, sad, afraid, jealous.

There seem to be three levels for each. Each of these levels corresponds to incerasing
levels of precision. 

Consider Fred being happy at his graduation about becoming a graduate. We have the
following contexts.

C2 -  the context where the topic of Freds happiness is completely implicit.
C1 -  the context where what aspect of his Graduation Fred is happy about is implicit.
C0 -  we are most precise here.

So we say,
  ist(happy(Fred),c2),       
  ist(happy(Fred, FredsGraduation),c1) and
  ist(happy(Fred, graduate(Fred)),c0).

We need some axioms which will lift (1) to (2) and so on. The following is a 
way of writting this lifting axiom (seems too general).

(1) ist(happy(x),c1) ≡ ist(happy(x, mainEvent(x,c1)), c2)

 We might want to make this a default.

The function mainEvent is a critical part of the above axiom. c1 talks about the
event about which a person happy explicitly but this is implicit in c2. To do the
lifting, we need to get our hands on this and this is what mainEvent is for.
The problem of extracting the value of arguments (to predicates) left implicit
in a context is discussed later.

The relation between happy, desires and beliefs. One has to be desirous of something
if he he going to be happy about it. He also has to believe that it is going to
be true. So we have the following.

(2) ist(happy(x,e) ⊃ ist(believes(x occurs(e))∧desires(x occurs(x))) c1)
(3) ist(happy(x,f) ⊃ ist(believes(x f)∧desires(x f) c0)

I am uncomfortable about the above axioms since it assumes that the second
beliefs argument for beliefs and desires is a fact. I'd like to be less commital
about that.

Time 
Nothing has been mentioned about the temporal aspects of happy etc. Ideally we
should be able to state our axioms about happiness etc. indepenent of the abstraction
of time used and then be able to `mix and match' any abstraction of time with 
any abstraction (c0,c1 or c2) used for emotions.

Consider two abstractions of time.
(a) We have a sequence of situations (which could be intervals or points) and facts
hold in situations.
(b) Each object (such as Fred) has temporal properties. So we have objects such as
FredAt4:15Today etc. These are arguments to predicates (there is no concept of fluents here).

The following are examples of axioms that specify how add (a) or (b) to c1.

(4) ist(happy(x),c2)∧situationOfContext(c2,s) ≡ ist(holds(happy(x),s), [c2,a])
(5) ist(happy(x),c2)∧ ∧situationOfContext(c2,s)∧ist(subAbsCotemporalWith(x,y,s),[c2,b]) ≡
	ist(happy(y),[c2,b])

Where [c2,b] denotes the composite context formed by combining c2 and b.

Actually axioms 1-5 are flawed in the following respect. c2 actually refers to a family
of contexts. All the elements of this class have a similar set of facts implicit in them.
To distinguish between them we can `parametarize' these elements. This can be done
either by making these contexts functions and having these implicit factors arguments
to these. This might turn out to be highly inadequate since we might later realize that
something else was also implicit in the context. So its better to consider these as rich
objects and have a set of predicates that apply to the context (examples of these
predicates include mainEvent and situationOfContext). We have to notationally
distinguish between these different elements. It might be usefull to consider these as
completely different contexts and refer to them as c11,c12...c1n. Then we can consider
c1 as a `context type' (also called g-microtheory in my proposal) and  if a context 
cnm does have all the axioms in c1 (also all that was implicit in c1) then we say
contextType(cnm,c1). Of course cnm could also fall into other cateogries. So in our
notation instead of [c1,a] we have a new object constant c1ai and have
contextType(c1ai, c1) and contextType(c1ai, a). 

This means we need to change axioms 1-5 but that seems quite simple.

So for example, (3) becomes

(6) contextType(ci,c0) ≡ ist(happy(x,f) ≡ ist(believes(x f)∧desires(x f) ci)

Since a large number of axioms are going to be of this form, we might want 
some special syntax for these class of statements. One option is to have

(7)  istT(happy(x,f) ≡ istT(believes(x f)∧desires(x f) c0)
and 
(8)  contextType(ci,cj)∧istT(p,cj) ⊃ ist(p,ci)

In the rest of this document I'll use the term context when I actually mean
contextType but the intended meaning should be clear from usage.



Simplifying/ coarsening theories by dropping arguments from predicates.


It might be possible to devise ways of writting the  axioms in simpler
context (types) that have a bunch of things implicit in them and automating
ways of going to the more complicated contexts than vice versa.

There seem to be the following cases under which we might be interested in dropping
arguments.
(a) Flexibility - the argument being dropped might be meant to incorporate some
aspect (such as time) and we want to be flexible about which abstraction of time
we use. So hopefully we should be able to `combine' the emotion (or other) axioms
with the axioms for different abstractions of time (or something else) to get the
`usable' theory.


(b) There exist situations where that argument becomes `degenerate' in one or
more of of the following ways.
 (i) None of the axioms is interested in the binding for that argument.
(ii) That argument is the same for all occurrances of the predicate.


The issue of apriori determining the existance of such situations is complicated
but is required since
(a) we need to determine when we can actually enter one of these specialized contexts
(b) having some abstraction of what exactly happens when we drop an argument might
tell us what additional axioms need to be supplied to lift the axioms when the
additional argument is added. 

Its possible that not all the axioms in one of these simpler theories
need to be liftable. The lifting needs to be done mainly to conclusions
of the simpler theory and these can be restricted to some subset of the
sentences in the theory. An argument for why we should be able to
restrict our attention (for lifting purposes) to some subset of the
formulae in a theory is as follows. 

Why do we put a set of formulae togather and call it a theory (and use
it in some context)? Presumably one expects to use these sentences
togather frequently. Why do we need to lift anything out of this theory?
Because our theories are not air-tight divisions and we might want
some interaction between theories. Now if all of the formulae in a theory
were candidates for lifting into another theory, maybe we should have merged
these two theories in the first place. So we have only restricted interaction
between theories and it might be a good idea to impose this restriction in
terms of the class of sentences that can be lifted out of a theory.

One class of formulae that might be be the most frequently lifted ones
is the class of ground formulae. I cant seem to come up with good
examples of lifting we cant do with lifting just ground formulae.

This class is also interesting because the lifting seems fairly straightforward.
First consider atomic formulae. (If we can lift an atomic formula p from 
context ca to context cb, lifting sentences constructed only out
of these formulae seems quite easy).

Given a formula p in context c, we cant expect to have a single axiom
that specifies how to lift it out of that context (assuming there is
no universal or outermost context. actually this might be a good reason
to assume (non-monotonically) that there is an outermost context).
So we need one lifting axiom for every pair of contexts (or context types).
Writting these axioms could be bothersome and so we need some easy way
of stating these. Here is one approach.

Consider two context types c3 and c2. c3 has the predicate p with two
arguments.  c2 has p with 3 arguments. When lifting a ground atomic
formula from c3 to c2, we need to extract this implicit argument. This
object has to be a function of only p, c3 and the two arguments to p in
c3. So for every predicate p with an argument suppressed in c3 (wrt c2),
we can introduce a function f such as f(x,y,c3i) where x and y are the
arguments to p in c3 and c3i is the actual context (i.e. contextType(c3i c3)). 
We might write this as liftingFunction(c3,c2,p,f).
The function mainEvent used for happy is an example of this. It might
so happen that a number of predicates share the same `lifting function'.

It seems reasonable to have the following axioms.
(liftedFormula(p1,c3,p2,c2) means that when we lift p1 from c3 to c2 we get p2)

ist((predicate x y),c3)∧liftingFunction(c3,c2,p,f) ⊃ ist((predicate x y (f x y c3)) c2)
(we will need such axioms for predicates of arity 3,4 etc.)

liftedFormula(p1,c3,p2,c2)∧ liftedFormula(pa,c3,pb,c2) ⊃
	liftedFormula(p1∨pa,c3,p2∨pb,c2)
and
liftedFormula(p1,c3,p2,c2) ⊃ liftedFormula(¬p1,c3,¬p2,c2)

These two should take care of lifting of ground formulae (when the main
problem is recovering implicit arguments) Using these axioms to do the
lifting of formulae with variables seem not good since we want to
eliminate the reference to the lifting functions once we have done the
lifting. If the term (f x y c3) has a variable in it, we might not be
able to replace it with an object constant (that is present in c2 - this
object constant might not be there in c3). If there is some other
function in c2 that is equal to (f x y c3) (that does not refer to c3)
we can use that, but I dont see the existance of such functions.

The next issue is determining when we can drop arguments, i.e. enter
the more special theory. 

Of course determining this could be very difficult. One way
to look at this is to check for cases where we can separate out
a set of axioms from a general theory and suppress some arguments to
some of the predicates in these axioms.
 Some extreme cases are - 

(a) we have a set of axioms which dont care about the binding for z. 
In this case, we can isolate these axioms. This happens if there is
only one occurrance of that variable in each of the axioms to be moved
to c2. We cant expect to lift (p x y) out of c3 into c2 (if we derive
it in c3). An example of this - consider c2 being about parties. It
contains the predicate happy and this takes 2 arguments (the person
who is happy and the event he is happy about). If there exists a set
of axioms that enable us to conclude that a person will have a good
time at a party if he is happy (these axioms dont really care what he
is happy about), then we can suppress the second argument to happy
and enter the context c3 in which happy has one argument to derive
whether some particular person will have a good time at some party.

(b) if z is a constant in all occurrances of p in a set of axioms.
Here (f x y c3i) is then equal to this constant. An example of this.
Consider a theory for determining what food to eat. If we have a 
predicate preferredFood(<foodType> <person> <mealtype>), we can expect
to have a set of axioms that talk about breakfast. In all these, the
<mealtype> argument is going to be Breakfast. So we can suppress this
and form a context with just these axioms.

However in general, it looks like for every pair of context types we 
need axioms that specify when to enter one from another. This might
not be all that bad if some of our context types are very general
(like `contexts that use discrete time', `contexts using continuous time'
etc.)

What is likely to happen in most cases is as follows. We have a set
of axioms involving some predicate p, (in which no argument is throughout
a constant or is ignored) but with some additional assumptions can
be reduced to a set of axioms in which one of these conditions is satisfied.
So if these assumptions are true, we can use the simpler context. 
example - in our party example, we might be interested in what the person
is happy about to determine whether he will have a good time at the party
since if the people hosting the party are opposed to the event that makes
him happy, then he wont enjoy the party. But we can have additional axioms
which say that if they are his friends, they are unlikely to oppose what
he is happy about. In this case, we dont need to bother about what he is
happy about (as long as he is happy about something). So if his friends
are trying to determine whether he will have a good time, they can work
in c3 where they dont worry about what is happy about. One possibility
is that the the only use of this variable is in the ab part of an axiom.
We might just assume that we are not dealing with an abnormal case, go
to the simpler context, get an answer and then check that this is not ab.
So the effect of what the person is happy about (on his having a good
time at the party) is thro an ab. 

Actually deducing this might be out of the question not just computationally
but also because in many cases we might not know precisely what these 
assumptions are.

Endless adding of arguments -
One can go on elaborating/ refining on a theory. This might require
adding additional arguments to predicates/functions. We obviously cant
add to many arguments to a predicate/function (no predicate/function
should take more than 5 or 6 arguments). We have to provide for some
abstraction for further refining a predicate that already has too
many arguments. The simplest scheme to do this is to reify occurrances
of the predicate and say things about this reified object. 
example. consider an action in situation calculus kill(<killer> <victim>).
We can go on adding arguments such as the instrument, whether it was painfull
etc. At some point we can reify this action to create a rich object
and rather than saying kill(Fred,Joe,Gun,PointBlank...) introduce a 
new object Killing001 and say performer(Killing001,Fred) and so on.
The justification is that if a predicate has 7 arguments, there are probably
a lot more things to really say about it.



`Mix and match'.
The aim is that we should be able to write axioms that say things
like - if a person is happy about something and that thing ceases
to be true, then the person is likely to be unhappy about that
thing ceasing to be true - without commiting to any particular
formalism for time. The idea is that we can then use different
formalisms for time under different cases (along with this axiom).

It seems to me that such axioms cant be stated with no reference to
time. This does not mean that we have to commit to some abstraction
of time while stating these. For example, the english statement above
does not commit to any particular model of time. We can do something
similar. We have a vocabulary of temporal terms which we use to
specify such axioms. However, there are no axioms that specify anything
about the temporal aspects of these terms. We can use different 
sets of axioms that define these terms to incorporate different
models of time. So in some sense, these axiomatizations are 
"pre-technical". (They are vague in just the way english terms such
as `after' or `causes' are and this is not something to avoid but to
exploit). Its possible that this strategy can be used for things
other than time.

Some such vague temporal terms include the following - after, start,
cease, occur, cause. I am not sure if these should be functions or
predicates. We might want to use some concepts such as sequence
of events etc. that seem to be present in all models of time,

Using a particular model of time might not be as painless as just adding
a set of axioms describing the temporal terms. The axioms might need
some reformulation. But since we need of these sets for each model of
time, and there are not that many models of time, this should not be tough.

Let me try to work out the above example -
if a person is happy about something and that thing ceases
to be true, then the person is likely to be unhappy about that
thing ceasing to be true.
Assume that we are using an abstraction of emotions in which people
are happy (or sad) about facts.
The above fact can be written as

after(happy(x p),ceases(p),unhappy(x ceases(p)))

To translate this to situation calculus we use the following axiom

istT(after(p event effect) cn) ⊃
	istT(holds(p, s)⊃ holds(effect, result(event, s)) [cn, sit-cal])

A similar axiom can be used to translate it to the subabstractions/histories
framework. Determining which abstraction of time to use is another important
thing (we can't (and should'nt be able to) derive any conclusions using 
the cn context).

Certain domains do use a more specialized model of time etc. and we might
want specialized  versions of this general vocabulary (still not very commital
about the exact model of time) for these.

Thanks for your comments. 

I have some responses to your suggestion
of using the function focus. Also, I think
I was'nt clear earlier about the notion
of context-types. 

I have written up something that discusses
both the issue of the focus function and
makes a case for context-types and shows
how they solve certain problems. I am sending
it to you in my next message.

Thanks

Guha


I want to discuss two issues here. The first is that of a general
approach towards explicating the values of arguments left
implicit in contexts. The second is an argument for the need for
theories/contexts corresponding to the notion of a theory as it
is used in the philosophy of science literature.

	(I) Explicating implicit arguments in contexts : If we
have a context c1 with a predicate p that takes 2 arguments (call
them x and y) and another context c2, that takes a third one too,
we need some way of computing the value of this third argument
when we lift a sentence of the form p(x y) from c1 to c2.

	The general approach is to associate with every predicate
in c1 that takes an extra argument in c2 a function of c1,c2 and
all the arguments to p in c1. This function term should be equal
to the value of the implicit argument.

	There are two issues.  (a) Should we have a function or
predicate to do this? - I dont see any major advantage of one
approach over an other, so I guess we should allow both.  (b)
What should be the arguments to this function?  In my note, I had
a function called mainEvent to lift the predicate happy from a
context in which it took one argument to one in which it took 2
argument. So we had,

	(1) ist(happy(x),c2) ≡ ist(happy(x, mainEvent(x,c2)), c1)

	You suggested I use

	(2) ist(happy(x),c2)∧ focusses(c2,z,c1) ≡ ist(happy(x,
z), c1)

	Here focusses is the analog of mainEvent with the main
difference (other than in the form) being that focusses is
independent of who is happy. I dont know if you intend having one
predicate (such as focusses) for each predicate (such as happy)
that has an implicit argument. I take it that you dont. If so,
this is capable of handling only those cases (of leaving an
argument implicit), where all occurraces of all implicit
arguments can be subsituted with the same constant. I think we
need something stronger than this.

	example : A set of people (say an alumni gathering) could
be having a discussion about how each of them felt at their
graduation. We might very well leave the second argument out of
happy here since given a person, we know the event in question.
If we want to lift this, since they could have graduated at
different times, we need a function that takes the person in
question (i.e. the explicit arguments to happy) as one of its
arguments.

	The point I am trying to make is that (a) We want to
allow for more than the case where all occurrances of an implicit
argument correspond to a single constant.  (b) If we want to do
(a), the implicit argument explicating function could potentially
need to take the contexts involved and all the explicit arguments
of the predicate involved as its arguments.

	(II) Context-types (this is probably a bad term):  In the
philosophy of science literature (pos), the term `theory' is used
to refer to a collectionof general axioms (such as f=m*a) that
dont refer to any specific bodies or objects.  One view of a
context is as a set of axioms or as a theory. It might be usefull
to include these general theories (in the pos sense) as a class
of contexts.

	Let me try to give an example of the utility of this
class of contexts.

	(a) Using our happiness example, consider the following
two uses of the context c2 (where happy takes a single argument).
(i) The first use involves a discussion of Fred and the context
has an associated time I0 which corresponds to the time around
Fred's graduation.  (i.e. one of the aspects of the context is
that all objects involved, explicit or implicit are within I0).
Further, the focus of the discussion is around his graduation. If
we want to lift this into a context c2, we have
focusses(c2,FredsGarduation,c1), or if we allow Fred to be an
argument to this, focusses(c2,Fred,FredsGraduation,c1).  (ii) The
second corresponds to a similar use of c1 and also deals with
Fred, except, that now the time associated is around the time
Fred got married. Now if we lift this discussion to c2, we get
focusses(c2,Fred,FredsMarriage,c1).

	It easy to see that having (i) and (ii) in the same KB
(something that seems quite reasonable) could lead to problems.
One approach to this problem is as follows.

	One complaint could be that I was sloppy about saying
that the context in which happy took one argument was c1 since I
not only left one argument implicit but also made assumptions
about the time period in concern. So I should have used some
other context ci which both has the second argument to happy
implicit and assumes some limited temporal focus. If we do this,
our two discussions (in which the argument to happy was left
implicit) turn out to be different contexts. (Call these two
contexts ci and cj).

	In general, we need to distinguish between a particular
type of simplification (or sets of these) (such as leaving an
argument to happy implicit) and a use of this. While it may be
possible to be rather precise about what exactly is assumed about
the former, and to consider them (i.e. sets of simplifications)
independently, this might not be possible for the later.  So it
may be possible to talk about the axioms of happiness (when happy
has just one argument) in the abstract (without commiting about
other issues such as temporal bounds of the context in which
these axioms are to be used), when we actually use these axioms
/predicates to say things in a discussion (i.e. about a
particular object), this will almost invariably involve making
other simplifications. The sum of these simplifications (which we
might not be able to explicate completely) itself forms another
context.

	However, all these different contexts that use happy as a
one place predicate share the general axioms about happiness and
we should need to state them only once.  My first shot at doing
this is as follows.

	Consider the class of all contexts that treat happy as a
one place predicate. Call this class CC1. To say that ci is a
context that treats happy as a one place predicate we say either
CC1(ci) or contextType(ci CC1).

	Now, consider a statement such as (3) ist((happy(x) ∧
likes(x y) ⊃ niceTo(x y)), ci)

	We want to derive this from somewhere else. Since we can
expect this to hold in all the contexts that belong to CC1
(including cj), that seems to be an appropriate place to put it.
So we can say,

	(4) istT((happy(x) ∧ likes(x y) ⊃ niceTo(x y)), CC1)

	(I use istT to say that something is true in all the
elements of some class of contexts).

	We would like to have the following hold strictly.

	(5) istT(p ct) ∧ contextType(ck, ct) ⊃ ist(p cl).

	Unfortunately we cant say this monotonically for the
following reason - contexts belonging to CC1 could also belong to
other context-types and the form of this axiom might need to
change based on those other context-types.

	example - CC1 says nothing about the temporal abstraction
used. If ci (which belongs to CC1) wants to use situation
calculus. So we have to restate (3) as

	(6) ist(holds((happy(x) ∧ likes(x y) ⊃ niceTo(x y)) s),
ci)

	Now we dont want to have to write a special axiom (or
anticipate the use of CC1 & situation calculus togather) to get
(6). Ideally we want to derive (6) from (4), the fact that ci
uses situation calculus and that ci belongs to CC1.

	[digression : In fact this is exactly the problem that
keeps us from saying

	(7) contextType(ci CC1) ⊃ ist((happy(x) ∧ likes(x y) ⊃
niceTo(x y)) ci)

	instead of having (4) and something like (5).]

	A partial solution to this problem is as follows.

	I want to distinguish between two classes of category
types. Those that make their entry quite painlessly and those
that dont. For example, one can see how ci can also belong to a
context-type that talks about furniture (possibly to state how
Fred felt about sitting on a chair with a nail sticking out
during his graduation) and it is unlikely that making ci belong
to this class of contexts is going to cause us to change the form
of the axioms from CC1. On the other hand, irrespective of which
formalism we use for time, it is unlikely that the axioms from
CC1 will remain completely untouched.

	So to get the axioms from the easy context types (such as
the one with axioms about furniture), we have, (8) easyToAdd(ct1)
∧ istT(p, ct1) ∧ contextType(ci, ct1) ⊃ ist(p ci).

	For those that are not easy to add here is one possible
approach.

	Since it is unlikely that there are going to be many of
these, we can hope to consider them when writting the axioms of
CC1 etc.  Though we might be prepared to consider time (and
possibly space) we dont want to commit to any particular
abstraction of time.

	So we want to talk about time, but without commiting to
any particular abstraction of time. One way to do this is to have
a `generic' temporal vocabulary to state th temporal aspects of
axioms in CC1. Based on the actual temporal formalism used, we
add additional axioms to make these general terms more
meaningfull. Alternately, we can associate a set of `templates'
with each of these temporal formalisms (since any instance of CC1
can be expected to use some temporal formalism) to translate the
axioms from CC1 to ci. An example of this is as follows.

	Instead of (4) we say,

	(9) istT((instantaneous (happy(x) ∧ likes(x y) ⊃ niceTo(x
y))) CC1)

	and to obtain (6) from (9) we use the following axiom,

	istT((instantaneous p), ct1) ∧ contextType(ci ct1) ∧
temporalFormalism(ci SitCal) ⊃
	ist(holds(p s), ci)

	One can see both how (a) Axioms for actions can be
translated using this template approach.  (b) The above axiom
itself could have been translated differently if ci had used
other abstractions of time.

	Concluding, the points I tried to make here (in (II))
were, (a) It might be usefull to distinguish between contexts and
classes of contexts that use a similar set of simplifications. (I
call the later general microtheories in my thesis proposal.)  (b)
We can profit by using `vague' terms in these context types and
translate the axioms / remove these vague terms when actually
using these axioms in a specific context based on the other
context types the specific context is an instance of.